JavaScript BigInti toimingud: suurte numbrite matemaatiline arvutus

JavaScript on ajalooliselt maadelnud väga suurte täisarvude täpse esitamisega, kuna selle Number-tüüp on kahekordse täpsusega 64-bitine binaarformaat (IEEE 754). See piirang muutub problemaatiliseks stsenaariumides, mis nõuavad täpsust, mis ületab Numberi pakutava, nagu krüptograafia, finantsarvutused või teaduslikud simulatsioonid. Sisenege BigInt, uus primitiivne andmetüüp JavaScriptis, mis on loodud suvalise pikkusega täisarvude esindamiseks.

Mis on BigInt?

BigInt on sisseehitatud objekt, mis pakub võimalust esitada täisarve, mis on suuremad kui 2⁵³ - 1, mis on maksimaalne turvaline täisarv, mida JavaScripti Number-tüüp saab täpselt esitada. Ilma BigIntita võib selle piiri ületavate numbritega arvutamine põhjustada täpsuse kadu ja valesid tulemusi. BigInt lahendab selle probleemi, võimaldades teil töötada suvaliselt suurte täisarvudega, kaotamata täpsust.

BigIntide loomine

Saate luua BigInti kahel viisil:

• Lisades n täisarvu literaali lõppu.
• Kutsudes BigInt() konstruktorit.

Siin on mõned näited:

const bigIntLiteral = 123456789012345678901234567890n;
const bigIntConstructor = BigInt(123456789012345678901234567890);
const bigIntFromString = BigInt("123456789012345678901234567890");

console.log(bigIntLiteral); // Väljund: 123456789012345678901234567890n
console.log(bigIntConstructor); // Väljund: 123456789012345678901234567890n
console.log(bigIntFromString); // Väljund: 123456789012345678901234567890n

Pange tähele, et saate luua BigInti numbrist, numbrit esindavast stringist või otse BigInti literaalina. Püüdes luua BigInti ujukomaarvust, saate RangeError.

Põhilised BigInti toimingud

BigInt toetab enamikku standardseid aritmeetilisi operaatoreid, sealhulgas liitmist, lahutamist, korrutamist, jagamist ja moodulit.

Aritmeetilised operaatorid

Siin on, kuidas kasutada põhilisi aritmeetilisi operaatoreid BigIntiga:

const a = 10n;
const b = 5n;

console.log(a + b); // Väljund: 15n (Liitmine)
console.log(a - b); // Väljund: 5n (Lahutamine)
console.log(a * b); // Väljund: 50n (Korrutamine)
console.log(a / b); // Väljund: 2n (Jagamine - kärbib nulli poole)
console.log(a % b); // Väljund: 0n (Moodul)
console.log(a ** b); // Väljund: 100000n (Astendamine)

Oluline märkus: Te ei saa aritmeetilistes toimingutes segada BigInte ja Numbreid. See põhjustab TypeError. Enne toimingu sooritamist peate Numberi sõnaselgelt BigIntiks teisendama.

const bigInt = 10n;
const number = 5;

// console.log(bigInt + number); // Visatakse TypeError
console.log(bigInt + BigInt(number)); // Väljund: 15n (Õige)

Võrdlusoperaatorid

BigInte saab võrrelda, kasutades standardseid võrdlusoperaatoreid:

const a = 10n;
const b = 5n;

console.log(a > b); // Väljund: true
console.log(a < b); // Väljund: false
console.log(a >= b); // Väljund: true
console.log(a <= b); // Väljund: false
console.log(a === b); // Väljund: false
console.log(a !== b); // Väljund: true

console.log(a == BigInt(10)); // Väljund: true
console.log(a === BigInt(10)); // Väljund: true

console.log(a == 10); // Väljund: true
console.log(a === 10); // Väljund: false

Kuigi saate kasutada lahtist võrdsust (==), et võrrelda BigInti Numberiga, on üldiselt soovitatav kasutada range võrdsust (===) ja teisendada Number sõnaselgelt BigIntiks selguse huvides ja soovimatute tüüpide koosseisu vältimiseks.

Bittide kaupa tehtavad operaatorid

BigIntid toetavad ka bitiviisilisi operaatoreid:

const a = 10n; // 1010 binaarselt
const b = 3n;  // 0011 binaarselt

console.log(a & b); // Väljund: 2n (Bittide kaupa JA)
console.log(a | b); // Väljund: 11n (Bittide kaupa VÕI)
console.log(a ^ b); // Väljund: 9n (Bittide kaupa XOR)
console.log(~a);  // Väljund: -11n (Bittide kaupa MITTE - kahendkujutis)
console.log(a << b); // Väljund: 80n (Vasak nihe)
console.log(a >> b); // Väljund: 1n (Parem nihe)
console.log(a >>> b); // Visatakse TypeError (allkirjata parem nihe ei ole BigInti jaoks toetatud)

Pange tähele, et allkirjata parema nihke operaatorit (>>>) ei toetata BigIntide puhul, sest BigIntid on alati allkirjastatud.

Täiustatud BigInti tehnikad

Raamatukogudega töötamine

Kuigi BigInt pakub suurarvude aritmeetika põhilisi ehitusplokke, võib spetsialiseeritud raamatukogude kasutamine oluliselt parandada jõudlust ja pakkuda täiendavaid funktsioone keerulisemate toimingute jaoks. Siin on mõned märkimisväärsed raamatukogud:

• jsbn: Kiire, kaasaskantav suurte numbrite matemaatika rakendus puhtas JavaScriptis.
• BigInteger.js: Teine populaarne raamatukogu, mis pakub kõikehõlmavat aritmeetiliste ja bitiviisiliste toimingute komplekti suvalise pikkusega täisarvude puhul.
• elliptic: Spetsiaalselt elliptiliste kõverate krüptograafia jaoks, mis sõltub suuresti BigInti aritmeetikast.

Need raamatukogud pakuvad sageli optimeeritud algoritme ja spetsiaalseid funktsioone, mis võivad olla kriitilise tähtsusega jõudluse suhtes tundlikes rakendustes.

Jõudluse kaalutlused

Kuigi BigInt võimaldab suvalist täpsust, on oluline olla teadlik selle jõudluse mõjust. BigInti toimingud on üldiselt aeglasemad kui Numberi toimingud, kuna need nõuavad rohkem mälu ja arvutusressursse. Seetõttu on oluline kasutada BigInti ainult siis, kui see on vajalik, ja optimeerida oma koodi jõudluse tagamiseks.

Siin on mõned näpunäited BigInti jõudluse optimeerimiseks:

• Vältige tarbetuid teisendusi: Minimeerige Numberite ja BigIntide vaheliste teisenduste arvu.
• Kasutage tõhusaid algoritme: Valige algoritmid, mis on optimeeritud suurarvude aritmeetika jaoks. Raamatukogud nagu jsbn ja BigInteger.js pakuvad sageli väga optimeeritud rakendusi.
• Profileerige oma koodi: Kasutage JavaScripti profileerimistööriistu, et tuvastada jõudlusnõrkused ja optimeerida oma koodi vastavalt.

Tüübiturvalisus

TypeScript pakub suurepärast tuge BigIntile, võimaldades teil jõustada tüübiturvalisust ja vältida vigu, mis on seotud BigIntide ja Numbrite segamisega. Saate muutujaid sõnaselgelt deklareerida BigIntina, et tagada nende ainult BigInti väärtuste hoidmine.

let bigIntValue: bigint = 12345678901234567890n;

// bigIntValue = 5; // TypeScript viskab vea, kuna proovite määrata numbri bigintile.

console.log(bigIntValue);

function addBigInts(a: bigint, b: bigint): bigint {
  return a + b;
}

console.log(addBigInts(10n, 20n)); // Väljund: 30n
// console.log(addBigInts(10, 20)); // TypeScript viskab vea

Kasutades TypeScripti tüübisüsteemi, saate potentsiaalsed vead varakult arendusprotsessis kinni püüda ja oma koodi töökindlust parandada.

BigInti reaalmaailma rakendused

BigIntid on olulised erinevates valdkondades, kus suurte täisarvude täpne käsitsemine on ülioluline. Uurime mõningaid olulisi rakendusi:

Krüptograafia

Krüptograafia tugineb suuresti suurtele algarvudele ja keerulistele matemaatilistele toimingutele, mis nõuavad suvalist täpsust. BigIntid on hädavajalikud krüptograafiliste algoritmide, nagu RSA, ECC (Elliptiliste kõverate krüptograafia) ja Diffie-Hellmani võtmevahetuse rakendamisel.

Näide: RSA krüpteerimine

RSA hõlmab suurte algarvude genereerimist ja modulaarset astendamist suurte täisarvudega. BigInte kasutatakse nende algarvude esindamiseks ja vajalike arvutuste tegemiseks ilma täpsuse kaotuseta. RSA turvalisus sõltub suurte numbrite tegurdamise raskusest, muutes BigIntid selle rakendamisel ülioluliseks.

Finantsarvutused

Finantsarvutused hõlmavad sageli suurte rahasummade käsitlemist või keerukate arvutuste tegemist suure täpsusega. BigInte saab kasutada rahaliste väärtuste täpseks esindamiseks ja ümardamisvigade vältimiseks, mis võivad tekkida ujukomaarvude kasutamisel. See on eriti oluline sellistes rakendustes nagu raamatupidamissüsteemid, pangandustarkvara ja finantsmudelid.

Näide: suure laenu intressi arvutamine

Suure laenu intressi arvutamisel võivad isegi väikesed ümardamisvead aja jooksul koguneda ja põhjustada olulisi lahknevusi. BigIntide kasutamine põhisumma, intressimäära ja muude asjakohaste väärtuste esindamiseks tagab, et arvutused on täpsed ja usaldusväärsed.

Teaduslik arvutus

Teaduslikud simulatsioonid ja arvutused hõlmavad sageli äärmiselt suurte või väikeste numbrite käsitlemist. BigInte saab kasutada nende numbrite täpseks esindamiseks ja vajalike arvutuste tegemiseks ilma täpsuse kaotuseta. See on eriti oluline sellistes valdkondades nagu astronoomia, füüsika ja keemia, kus täpsus on ülimalt tähtis.

Näide: Mooli aatomite arvu arvutamine

Avogadro arv (ligikaudu 6,022 x 10²³) esindab aatomite arvu aine moolis. See arv on kaugelt üle JavaScripti Number-tüübi turvalise täisarvu piiri. BigIntide kasutamine võimaldab teil Avogadro arvu täpselt esindada ja sellega seotud arvutusi teha ilma täpsust kaotamata.

Kõrge täpsusega ajatemplid

Jaotatud süsteemides või kõrgsageduslikus kauplemises on täpsed ajatemplid olulised andmete järjepidevuse säilitamiseks ja sündmuste õigeks järjestamiseks. BigInte saab kasutada ajatemplite esitamiseks nanosekundi või isegi pikosekundi täpsusega, tagades, et sündmused on järjestatud täpselt isegi stsenaariumides, kus sündmuste määr on äärmiselt suur.

Plokiahela tehnoloogia

Plokiahela tehnoloogia tugineb suuresti krüptograafilistele toimingutele ja suurarvude aritmeetikale. BigInte kasutatakse tehingute ID-de, ploki räside ja muude krüptograafiliste väärtuste esitamiseks suure täpsusega. Neid kasutatakse ka nutilepingutes keeruliste arvutuste tegemiseks ja finantsreeglite jõustamiseks, tuginedes ujukomaarvudele.

Näide: Ethereum Smart Contracts

Ethereum smart contracts hõlmavad sageli keerukaid finantsarvutusi ja digitaalsete varade haldamist. BigIntide kasutamine tagab, et need arvutused tehakse täpselt ja varade väärtused on esitatud ilma ümardamisvigadeta.

Brauseri ühilduvus

BigIntil on suurepärane brauseritugi kaasaegsetes brauserites, sealhulgas Chrome, Firefox, Safari ja Edge. Kuid on oluline arvestada brauseri ühilduvusega, kui arendate rakendusi, mis peavad toetama vanemaid brausereid. Saate kasutada polyfill'e või transpileerijaid, nagu Babel, et pakkuda BigInti tuge vanematele brauseritele. Paljudel vanematel brauseritel ei ole natiivset BigInti tuge, kuid funktsionaalsuse lisamiseks on saadaval polyfillid. Värskendatud diagrammi leiate veebisaidilt CanIUse.

Näiteks Babel saab teie koodi, kasutades BigInti, transpileerida samaväärseks koodiks, mis töötab isegi vanemates Javascripti mootorites.

Teisendamine teisteks tüüpideks ja nendest

BigInti ja muude JavaScripti tüüpide vahel teisendamine nõuab sõnaselget teisendamist. Siin on reeglid:

• Numbrisse: Kasutage Number(bigIntValue). Olge ettevaatlik, sest see võib põhjustada täpsuse kadu, kui BigInt on liiga suur.
• Stringiks: Kasutage String(bigIntValue). See on üldiselt ohutu ja annab BigInti stringiesituse.
• Numbrist: Kasutage BigInt(numberValue). See on soovitatav ainult täisarvuliste numbrite jaoks. Ujukomaarvud, mis on edastatud BigInti konstruktorile, viskavad RangeErrori.
• Stringist: Kasutage BigInt(stringValue). String peab esindama täisarvu, vastasel juhul ilmneb SyntaxError.

let bigIntVal = 123456789012345678901234567890n;
let numVal = Number(bigIntVal); // Potentsiaalselt kadudega teisendus
let strVal = String(bigIntVal); // Ohutu teisendus stringiks

console.log(numVal); // Näitab täpsuse kadu.
console.log(strVal);

let newBigInt = BigInt(100); // Loob täisarvulisest numbrist

console.log(newBigInt);

let newBigIntFromString = BigInt("98765432109876543210"); // stringist

console.log(newBigIntFromString);

// BigInt(3.14); // põhjustab vahemiku vea

Lõkse ja kaalutlusi

Kuigi BigIntid on uskumatult kasulikud, peaksite teadma teatud lõkse:

• Tüüpi vead: Pidage meeles, et BigInte ei saa aritmeetilistes toimingutes otse segada Numbritega.
• Jõudlus: BigInti toimingud on aeglasemad kui standardnumbrite toimingud.
• Täpsuse kadu: Väga suurte BigIntide teisendamine Numbriteks võib põhjustada täpsuse kadu Numberi tüübi piirangute tõttu.
• Standardraamatukogu toe puudumine: Kõik standardseid JavaScripti meetodeid ei ühildu otse BigIntidega. Peate võib-olla rakendama kohandatud funktsioone või kasutama raamatukogusid, mis toetavad sõnaselgelt BigInte.
• Operaatorite prioriteet: Olge bitiviisiliste operaatoritega BigIntide kasutamisel operaatorite prioriteediga ettevaatlik.

Järeldus

BigInt on võimas täiendus JavaScriptile, mis võimaldab arendajatel töötada suvaliselt suurte täisarvudega, kaotamata täpsust. See võimalus on hädavajalik mitmesugustes valdkondades, sealhulgas krüptograafia, finantsarvutused, teadusarvutus ja plokiahela tehnoloogia. Mõistes BigInti toimingute põhialuseid, jõudluse kaalutlusi ja reaalmaailma rakendusi, saavad arendajad seda andmetüüpi kasutada tugevamate ja usaldusväärsemate rakenduste loomiseks, mis nõuavad suurte numbrite täpset käsitlemist. Kuigi on mõningaid jõudluse ja tüübi kaalutlusi, on BigInti kasutamise eelised vajadusel märkimisväärsed.

Kuna JavaScript areneb edasi, mängib BigInt kahtlemata üha olulisemat rolli, võimaldades arendajatel lahendada keerukaid probleeme, mis nõuavad suvalist täpsuse aritmeetikat. Maailm tugineb üha enam arvutustele ja täpsus on ülimalt tähtis.

Pidage seda põhjalikku juhendit lähtepunktiks, süvenege raamatukogudesse ja uurige loomingulisi viise BigInti rakendamiseks oma projektides.